// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.amazon.reimbursements;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.AmazonReimbursements;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(AmazonReimbursements.class)
@Setter
@Getter
public class AmazonReimbursementsSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "AmazonReimbursements".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("sid", "si");
    map.put("country", "sr");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String sidShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String sidShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String sidShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String sidShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String sidShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String sidShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String sidShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String sidShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String sidShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String sidShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean sidShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean sidShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> sidInList;

  /**
   * 国家
   */
  private Long country;

  /**
   * 国家 比较(eq)
   */
  private Long countryEq;
  /**
   * 国家 比较(neq)
   */
  private Long countryNeq;
  /**
   * 国家 比较(gt)
   */
  private Long countryGt;
  /**
   * 国家 比较(gte)
   */
  private Long countryGte;
  /**
   * 国家 比较(lt)
   */
  private Long countryLt;
  /**
   * 国家 比较(lte)
   */
  private Long countryLte;
  /**
   * 国家 比较(contains)
   */
  private Long countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private Long countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private Long countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private Long countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;
  /**
   * 国家的名称 比较(eq)
   */
  private String countryNameEq;
  /**
   * 国家的名称 比较(neq)
   */
  private String countryNameNeq;
  /**
   * 国家的名称 比较(gt)
   */
  private String countryNameGt;
  /**
   * 国家的名称 比较(gte)
   */
  private String countryNameGte;
  /**
   * 国家的名称 比较(lt)
   */
  private String countryNameLt;
  /**
   * 国家的名称 比较(lte)
   */
  private String countryNameLte;
  /**
   * 国家的名称 比较(contains)
   */
  private String countryNameContains;
  /**
   * 国家的名称 比较(notcontains)
   */
  private String countryNameNotcontains;
  /**
   * 国家的名称 比较(startswith)
   */
  private String countryNameStartswith;
  /**
   * 国家的名称 比较(endswith)
   */
  private String countryNameEndswith;
  /**
   * 国家的名称 比较(isnull)
   */
  private Boolean countryNameIsnull;
  /**
   * 国家的名称 比较(isnotnull)
   */
  private Boolean countryNameIsnotnull;

  /**
   * 国家(范围搜索)
   */
  private List<Long> countryInList;

  /**
   * 最早批准日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date approvalDateStart;

  /**
   * 最晚批准日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date approvalDateEnd;

  /**
   * 批准日期 比较(eq)
   */
  private Date approvalDateEq;
  /**
   * 批准日期 比较(neq)
   */
  private Date approvalDateNeq;
  /**
   * 批准日期 比较(gt)
   */
  private Date approvalDateGt;
  /**
   * 批准日期 比较(gte)
   */
  private Date approvalDateGte;
  /**
   * 批准日期 比较(lt)
   */
  private Date approvalDateLt;
  /**
   * 批准日期 比较(lte)
   */
  private Date approvalDateLte;
  /**
   * 批准日期 比较(contains)
   */
  private Date approvalDateContains;
  /**
   * 批准日期 比较(notcontains)
   */
  private Date approvalDateNotcontains;
  /**
   * 批准日期 比较(startswith)
   */
  private Date approvalDateStartswith;
  /**
   * 批准日期 比较(endswith)
   */
  private Date approvalDateEndswith;
  /**
   * 批准日期 比较(isnull)
   */
  private Boolean approvalDateIsnull;
  /**
   * 批准日期 比较(isnotnull)
   */
  private Boolean approvalDateIsnotnull;

  /**
   * 赔偿编号(模糊搜索)
   */
  private String reimbursementId;

  /**
   * 赔偿编号 比较(eq)
   */
  private String reimbursementIdEq;
  /**
   * 赔偿编号 比较(neq)
   */
  private String reimbursementIdNeq;
  /**
   * 赔偿编号 比较(gt)
   */
  private String reimbursementIdGt;
  /**
   * 赔偿编号 比较(gte)
   */
  private String reimbursementIdGte;
  /**
   * 赔偿编号 比较(lt)
   */
  private String reimbursementIdLt;
  /**
   * 赔偿编号 比较(lte)
   */
  private String reimbursementIdLte;
  /**
   * 赔偿编号 比较(contains)
   */
  private String reimbursementIdContains;
  /**
   * 赔偿编号 比较(notcontains)
   */
  private String reimbursementIdNotcontains;
  /**
   * 赔偿编号 比较(startswith)
   */
  private String reimbursementIdStartswith;
  /**
   * 赔偿编号 比较(endswith)
   */
  private String reimbursementIdEndswith;
  /**
   * 赔偿编号 比较(isnull)
   */
  private Boolean reimbursementIdIsnull;
  /**
   * 赔偿编号 比较(isnotnull)
   */
  private Boolean reimbursementIdIsnotnull;

  /**
   * 赔偿编号(精确搜索)
   */
  private List<String> reimbursementIdInList;

  /**
   * 问题编号(模糊搜索)
   */
  private String caseId;

  /**
   * 问题编号 比较(eq)
   */
  private String caseIdEq;
  /**
   * 问题编号 比较(neq)
   */
  private String caseIdNeq;
  /**
   * 问题编号 比较(gt)
   */
  private String caseIdGt;
  /**
   * 问题编号 比较(gte)
   */
  private String caseIdGte;
  /**
   * 问题编号 比较(lt)
   */
  private String caseIdLt;
  /**
   * 问题编号 比较(lte)
   */
  private String caseIdLte;
  /**
   * 问题编号 比较(contains)
   */
  private String caseIdContains;
  /**
   * 问题编号 比较(notcontains)
   */
  private String caseIdNotcontains;
  /**
   * 问题编号 比较(startswith)
   */
  private String caseIdStartswith;
  /**
   * 问题编号 比较(endswith)
   */
  private String caseIdEndswith;
  /**
   * 问题编号 比较(isnull)
   */
  private Boolean caseIdIsnull;
  /**
   * 问题编号 比较(isnotnull)
   */
  private Boolean caseIdIsnotnull;

  /**
   * 问题编号(精确搜索)
   */
  private List<String> caseIdInList;

  /**
   * 订单号(模糊搜索)
   */
  private String amazonOrderId;

  /**
   * 订单号 比较(eq)
   */
  private String amazonOrderIdEq;
  /**
   * 订单号 比较(neq)
   */
  private String amazonOrderIdNeq;
  /**
   * 订单号 比较(gt)
   */
  private String amazonOrderIdGt;
  /**
   * 订单号 比较(gte)
   */
  private String amazonOrderIdGte;
  /**
   * 订单号 比较(lt)
   */
  private String amazonOrderIdLt;
  /**
   * 订单号 比较(lte)
   */
  private String amazonOrderIdLte;
  /**
   * 订单号 比较(contains)
   */
  private String amazonOrderIdContains;
  /**
   * 订单号 比较(notcontains)
   */
  private String amazonOrderIdNotcontains;
  /**
   * 订单号 比较(startswith)
   */
  private String amazonOrderIdStartswith;
  /**
   * 订单号 比较(endswith)
   */
  private String amazonOrderIdEndswith;
  /**
   * 订单号 比较(isnull)
   */
  private Boolean amazonOrderIdIsnull;
  /**
   * 订单号 比较(isnotnull)
   */
  private Boolean amazonOrderIdIsnotnull;

  /**
   * 订单号(精确搜索)
   */
  private List<String> amazonOrderIdInList;

  /**
   * 原因(模糊搜索)
   */
  private String reason;

  /**
   * 原因 比较(eq)
   */
  private String reasonEq;
  /**
   * 原因 比较(neq)
   */
  private String reasonNeq;
  /**
   * 原因 比较(gt)
   */
  private String reasonGt;
  /**
   * 原因 比较(gte)
   */
  private String reasonGte;
  /**
   * 原因 比较(lt)
   */
  private String reasonLt;
  /**
   * 原因 比较(lte)
   */
  private String reasonLte;
  /**
   * 原因 比较(contains)
   */
  private String reasonContains;
  /**
   * 原因 比较(notcontains)
   */
  private String reasonNotcontains;
  /**
   * 原因 比较(startswith)
   */
  private String reasonStartswith;
  /**
   * 原因 比较(endswith)
   */
  private String reasonEndswith;
  /**
   * 原因 比较(isnull)
   */
  private Boolean reasonIsnull;
  /**
   * 原因 比较(isnotnull)
   */
  private Boolean reasonIsnotnull;

  /**
   * 原因(精确搜索)
   */
  private List<String> reasonInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * 标题(模糊搜索)
   */
  private String itemName;

  /**
   * 标题 比较(eq)
   */
  private String itemNameEq;
  /**
   * 标题 比较(neq)
   */
  private String itemNameNeq;
  /**
   * 标题 比较(gt)
   */
  private String itemNameGt;
  /**
   * 标题 比较(gte)
   */
  private String itemNameGte;
  /**
   * 标题 比较(lt)
   */
  private String itemNameLt;
  /**
   * 标题 比较(lte)
   */
  private String itemNameLte;
  /**
   * 标题 比较(contains)
   */
  private String itemNameContains;
  /**
   * 标题 比较(notcontains)
   */
  private String itemNameNotcontains;
  /**
   * 标题 比较(startswith)
   */
  private String itemNameStartswith;
  /**
   * 标题 比较(endswith)
   */
  private String itemNameEndswith;
  /**
   * 标题 比较(isnull)
   */
  private Boolean itemNameIsnull;
  /**
   * 标题 比较(isnotnull)
   */
  private Boolean itemNameIsnotnull;

  /**
   * 标题(精确搜索)
   */
  private List<String> itemNameInList;

  /**
   * 状况(模糊搜索)
   */
  private String condition;

  /**
   * 状况 比较(eq)
   */
  private String conditionEq;
  /**
   * 状况 比较(neq)
   */
  private String conditionNeq;
  /**
   * 状况 比较(gt)
   */
  private String conditionGt;
  /**
   * 状况 比较(gte)
   */
  private String conditionGte;
  /**
   * 状况 比较(lt)
   */
  private String conditionLt;
  /**
   * 状况 比较(lte)
   */
  private String conditionLte;
  /**
   * 状况 比较(contains)
   */
  private String conditionContains;
  /**
   * 状况 比较(notcontains)
   */
  private String conditionNotcontains;
  /**
   * 状况 比较(startswith)
   */
  private String conditionStartswith;
  /**
   * 状况 比较(endswith)
   */
  private String conditionEndswith;
  /**
   * 状况 比较(isnull)
   */
  private Boolean conditionIsnull;
  /**
   * 状况 比较(isnotnull)
   */
  private Boolean conditionIsnotnull;

  /**
   * 状况(精确搜索)
   */
  private List<String> conditionInList;

  /**
   * 币种
   */
  private String currencyUnit;

  /**
   * 币种 比较(eq)
   */
  private String currencyUnitEq;
  /**
   * 币种 比较(neq)
   */
  private String currencyUnitNeq;
  /**
   * 币种 比较(gt)
   */
  private String currencyUnitGt;
  /**
   * 币种 比较(gte)
   */
  private String currencyUnitGte;
  /**
   * 币种 比较(lt)
   */
  private String currencyUnitLt;
  /**
   * 币种 比较(lte)
   */
  private String currencyUnitLte;
  /**
   * 币种 比较(contains)
   */
  private String currencyUnitContains;
  /**
   * 币种 比较(notcontains)
   */
  private String currencyUnitNotcontains;
  /**
   * 币种 比较(startswith)
   */
  private String currencyUnitStartswith;
  /**
   * 币种 比较(endswith)
   */
  private String currencyUnitEndswith;
  /**
   * 币种 比较(isnull)
   */
  private Boolean currencyUnitIsnull;
  /**
   * 币种 比较(isnotnull)
   */
  private Boolean currencyUnitIsnotnull;

  /**
   * 币种(精确搜索)
   */
  private List<String> currencyUnitInList;

  /**
   * 每件商品赔偿金额(模糊搜索)
   */
  private String amountPerUnit;

  /**
   * 每件商品赔偿金额 比较(eq)
   */
  private String amountPerUnitEq;
  /**
   * 每件商品赔偿金额 比较(neq)
   */
  private String amountPerUnitNeq;
  /**
   * 每件商品赔偿金额 比较(gt)
   */
  private String amountPerUnitGt;
  /**
   * 每件商品赔偿金额 比较(gte)
   */
  private String amountPerUnitGte;
  /**
   * 每件商品赔偿金额 比较(lt)
   */
  private String amountPerUnitLt;
  /**
   * 每件商品赔偿金额 比较(lte)
   */
  private String amountPerUnitLte;
  /**
   * 每件商品赔偿金额 比较(contains)
   */
  private String amountPerUnitContains;
  /**
   * 每件商品赔偿金额 比较(notcontains)
   */
  private String amountPerUnitNotcontains;
  /**
   * 每件商品赔偿金额 比较(startswith)
   */
  private String amountPerUnitStartswith;
  /**
   * 每件商品赔偿金额 比较(endswith)
   */
  private String amountPerUnitEndswith;
  /**
   * 每件商品赔偿金额 比较(isnull)
   */
  private Boolean amountPerUnitIsnull;
  /**
   * 每件商品赔偿金额 比较(isnotnull)
   */
  private Boolean amountPerUnitIsnotnull;

  /**
   * 每件商品赔偿金额(精确搜索)
   */
  private List<String> amountPerUnitInList;

  /**
   * 总金额(模糊搜索)
   */
  private String amountTotal;

  /**
   * 总金额 比较(eq)
   */
  private String amountTotalEq;
  /**
   * 总金额 比较(neq)
   */
  private String amountTotalNeq;
  /**
   * 总金额 比较(gt)
   */
  private String amountTotalGt;
  /**
   * 总金额 比较(gte)
   */
  private String amountTotalGte;
  /**
   * 总金额 比较(lt)
   */
  private String amountTotalLt;
  /**
   * 总金额 比较(lte)
   */
  private String amountTotalLte;
  /**
   * 总金额 比较(contains)
   */
  private String amountTotalContains;
  /**
   * 总金额 比较(notcontains)
   */
  private String amountTotalNotcontains;
  /**
   * 总金额 比较(startswith)
   */
  private String amountTotalStartswith;
  /**
   * 总金额 比较(endswith)
   */
  private String amountTotalEndswith;
  /**
   * 总金额 比较(isnull)
   */
  private Boolean amountTotalIsnull;
  /**
   * 总金额 比较(isnotnull)
   */
  private Boolean amountTotalIsnotnull;

  /**
   * 总金额(精确搜索)
   */
  private List<String> amountTotalInList;

  /**
   * 赔偿数量（现金）
   */
  private Integer quantityReimbursedCash;

  /**
   * 最小赔偿数量（现金）
   */
  private Integer quantityReimbursedCashMin;

  /**
   * 最大赔偿数量（现金）
   */
  private Integer quantityReimbursedCashMax;

  /**
   * 赔偿数量（现金） 比较(eq)
   */
  private Integer quantityReimbursedCashEq;
  /**
   * 赔偿数量（现金） 比较(neq)
   */
  private Integer quantityReimbursedCashNeq;
  /**
   * 赔偿数量（现金） 比较(gt)
   */
  private Integer quantityReimbursedCashGt;
  /**
   * 赔偿数量（现金） 比较(gte)
   */
  private Integer quantityReimbursedCashGte;
  /**
   * 赔偿数量（现金） 比较(lt)
   */
  private Integer quantityReimbursedCashLt;
  /**
   * 赔偿数量（现金） 比较(lte)
   */
  private Integer quantityReimbursedCashLte;
  /**
   * 赔偿数量（现金） 比较(contains)
   */
  private Integer quantityReimbursedCashContains;
  /**
   * 赔偿数量（现金） 比较(notcontains)
   */
  private Integer quantityReimbursedCashNotcontains;
  /**
   * 赔偿数量（现金） 比较(startswith)
   */
  private Integer quantityReimbursedCashStartswith;
  /**
   * 赔偿数量（现金） 比较(endswith)
   */
  private Integer quantityReimbursedCashEndswith;
  /**
   * 赔偿数量（现金） 比较(isnull)
   */
  private Boolean quantityReimbursedCashIsnull;
  /**
   * 赔偿数量（现金） 比较(isnotnull)
   */
  private Boolean quantityReimbursedCashIsnotnull;

  /**
   * 赔偿数量（库存）
   */
  private Integer quantityReimbursedInventory;

  /**
   * 最小赔偿数量（库存）
   */
  private Integer quantityReimbursedInventoryMin;

  /**
   * 最大赔偿数量（库存）
   */
  private Integer quantityReimbursedInventoryMax;

  /**
   * 赔偿数量（库存） 比较(eq)
   */
  private Integer quantityReimbursedInventoryEq;
  /**
   * 赔偿数量（库存） 比较(neq)
   */
  private Integer quantityReimbursedInventoryNeq;
  /**
   * 赔偿数量（库存） 比较(gt)
   */
  private Integer quantityReimbursedInventoryGt;
  /**
   * 赔偿数量（库存） 比较(gte)
   */
  private Integer quantityReimbursedInventoryGte;
  /**
   * 赔偿数量（库存） 比较(lt)
   */
  private Integer quantityReimbursedInventoryLt;
  /**
   * 赔偿数量（库存） 比较(lte)
   */
  private Integer quantityReimbursedInventoryLte;
  /**
   * 赔偿数量（库存） 比较(contains)
   */
  private Integer quantityReimbursedInventoryContains;
  /**
   * 赔偿数量（库存） 比较(notcontains)
   */
  private Integer quantityReimbursedInventoryNotcontains;
  /**
   * 赔偿数量（库存） 比较(startswith)
   */
  private Integer quantityReimbursedInventoryStartswith;
  /**
   * 赔偿数量（库存） 比较(endswith)
   */
  private Integer quantityReimbursedInventoryEndswith;
  /**
   * 赔偿数量（库存） 比较(isnull)
   */
  private Boolean quantityReimbursedInventoryIsnull;
  /**
   * 赔偿数量（库存） 比较(isnotnull)
   */
  private Boolean quantityReimbursedInventoryIsnotnull;

  /**
   * 赔偿数量（总计）
   */
  private Integer quantityReimbursedTotal;

  /**
   * 最小赔偿数量（总计）
   */
  private Integer quantityReimbursedTotalMin;

  /**
   * 最大赔偿数量（总计）
   */
  private Integer quantityReimbursedTotalMax;

  /**
   * 赔偿数量（总计） 比较(eq)
   */
  private Integer quantityReimbursedTotalEq;
  /**
   * 赔偿数量（总计） 比较(neq)
   */
  private Integer quantityReimbursedTotalNeq;
  /**
   * 赔偿数量（总计） 比较(gt)
   */
  private Integer quantityReimbursedTotalGt;
  /**
   * 赔偿数量（总计） 比较(gte)
   */
  private Integer quantityReimbursedTotalGte;
  /**
   * 赔偿数量（总计） 比较(lt)
   */
  private Integer quantityReimbursedTotalLt;
  /**
   * 赔偿数量（总计） 比较(lte)
   */
  private Integer quantityReimbursedTotalLte;
  /**
   * 赔偿数量（总计） 比较(contains)
   */
  private Integer quantityReimbursedTotalContains;
  /**
   * 赔偿数量（总计） 比较(notcontains)
   */
  private Integer quantityReimbursedTotalNotcontains;
  /**
   * 赔偿数量（总计） 比较(startswith)
   */
  private Integer quantityReimbursedTotalStartswith;
  /**
   * 赔偿数量（总计） 比较(endswith)
   */
  private Integer quantityReimbursedTotalEndswith;
  /**
   * 赔偿数量（总计） 比较(isnull)
   */
  private Boolean quantityReimbursedTotalIsnull;
  /**
   * 赔偿数量（总计） 比较(isnotnull)
   */
  private Boolean quantityReimbursedTotalIsnotnull;

  /**
   * 原始赔偿编号(模糊搜索)
   */
  private String originalReimbursementId;

  /**
   * 原始赔偿编号 比较(eq)
   */
  private String originalReimbursementIdEq;
  /**
   * 原始赔偿编号 比较(neq)
   */
  private String originalReimbursementIdNeq;
  /**
   * 原始赔偿编号 比较(gt)
   */
  private String originalReimbursementIdGt;
  /**
   * 原始赔偿编号 比较(gte)
   */
  private String originalReimbursementIdGte;
  /**
   * 原始赔偿编号 比较(lt)
   */
  private String originalReimbursementIdLt;
  /**
   * 原始赔偿编号 比较(lte)
   */
  private String originalReimbursementIdLte;
  /**
   * 原始赔偿编号 比较(contains)
   */
  private String originalReimbursementIdContains;
  /**
   * 原始赔偿编号 比较(notcontains)
   */
  private String originalReimbursementIdNotcontains;
  /**
   * 原始赔偿编号 比较(startswith)
   */
  private String originalReimbursementIdStartswith;
  /**
   * 原始赔偿编号 比较(endswith)
   */
  private String originalReimbursementIdEndswith;
  /**
   * 原始赔偿编号 比较(isnull)
   */
  private Boolean originalReimbursementIdIsnull;
  /**
   * 原始赔偿编号 比较(isnotnull)
   */
  private Boolean originalReimbursementIdIsnotnull;

  /**
   * 原始赔偿编号(精确搜索)
   */
  private List<String> originalReimbursementIdInList;

  /**
   * 赔偿类型(模糊搜索)
   */
  private String originalReimbursementType;

  /**
   * 赔偿类型 比较(eq)
   */
  private String originalReimbursementTypeEq;
  /**
   * 赔偿类型 比较(neq)
   */
  private String originalReimbursementTypeNeq;
  /**
   * 赔偿类型 比较(gt)
   */
  private String originalReimbursementTypeGt;
  /**
   * 赔偿类型 比较(gte)
   */
  private String originalReimbursementTypeGte;
  /**
   * 赔偿类型 比较(lt)
   */
  private String originalReimbursementTypeLt;
  /**
   * 赔偿类型 比较(lte)
   */
  private String originalReimbursementTypeLte;
  /**
   * 赔偿类型 比较(contains)
   */
  private String originalReimbursementTypeContains;
  /**
   * 赔偿类型 比较(notcontains)
   */
  private String originalReimbursementTypeNotcontains;
  /**
   * 赔偿类型 比较(startswith)
   */
  private String originalReimbursementTypeStartswith;
  /**
   * 赔偿类型 比较(endswith)
   */
  private String originalReimbursementTypeEndswith;
  /**
   * 赔偿类型 比较(isnull)
   */
  private Boolean originalReimbursementTypeIsnull;
  /**
   * 赔偿类型 比较(isnotnull)
   */
  private Boolean originalReimbursementTypeIsnotnull;

  /**
   * 赔偿类型(精确搜索)
   */
  private List<String> originalReimbursementTypeInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
